home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / Text.C < prev    next >
C/C++ Source or Header  |  1992-08-26  |  11KB  |  599 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "Text.h"
  6.  
  7. #include "Class.h"
  8. #include "Error.h"
  9. #include "RegularExp.h"
  10. #include "Mark.h"
  11. #include "Port.h"
  12. #include "OrdColl.h"
  13. #include "Math.h"
  14.  
  15. //---- formating properties ----------------------------------------------------
  16.  
  17. byte TextCharMap[] = {
  18. cTextBreak|cTextPara,         /* 0x00 */
  19. 0,                            /* 0x01 */
  20. 0,                            /* 0x02 */
  21. 0,                            /* 0x03 */
  22. 0,                            /* 0x04 */
  23. 0,                            /* 0x05 */
  24. 0,                            /* 0x06 */
  25. 0,                            /* 0x07 */
  26. 0,                            /* 0x08 */
  27. 0,                            /* 0x09 */
  28. cTextBreak|cTextPara,         /* 0x0a */
  29. 0,                            /* 0x0b */
  30. cTextBreak,                   /* 0x0c */
  31. cTextBreak,                   /* 0x0d */
  32. 0,                            /* 0x0e */
  33. 0,                            /* 0x0f */
  34. 0,                            /* 0x10 */
  35. 0,                            /* 0x11 */
  36. 0,                            /* 0x12 */
  37. 0,                            /* 0x13 */
  38. 0,                            /* 0x14 */
  39. 0,                            /* 0x15 */
  40. 0,                            /* 0x16 */
  41. 0,                            /* 0x17 */
  42. 0,                            /* 0x18 */
  43. 0,                            /* 0x19 */
  44. 0,                            /* 0x1a */
  45. 0,                            /* 0x1b */
  46. 0,                            /* 0x1c */
  47. 0,                            /* 0x1d */
  48. 0,                            /* 0x1e */
  49. 0,                            /* 0x1f */
  50. };
  51.  
  52. static TextChanges changeRec;
  53.  
  54. //---- VisualMark -----------------------------------------------------
  55.  
  56. NewMetaImpl0(VisualMark,Mark);
  57.  
  58. VisualMark::VisualMark() : Mark(0, 0, eStateNone, eMarkFixedSize)
  59.  
  60. {
  61. }
  62.     
  63. void VisualMark::CalcExtent()
  64. {
  65. }
  66.  
  67. int VisualMark::Base()
  68. {
  69.     return GetExtent().y;
  70. }
  71.  
  72. Point VisualMark::GetExtent()
  73. {
  74.     return gPoint0;
  75. }
  76.     
  77. void VisualMark::Draw(Point, Rectangle, Rectangle, bool)
  78. {
  79. }
  80.  
  81. void VisualMark::SendDown(int, int, void *)
  82. {
  83. }
  84.  
  85. void VisualMark::SetContainer(class VObject *)
  86. {
  87. }
  88.  
  89. bool VisualMark::WantsInput(Point)
  90. {
  91.     return FALSE;
  92. }
  93.  
  94. class Command *VisualMark::Input(Point, Token&, class Clipper *)
  95. {
  96.     return 0;
  97. }
  98.  
  99. class VObject *VisualMark::GetVObject()
  100. {
  101.     return 0;
  102. }
  103.  
  104. //---- Text ------------------------------------------------------------
  105.  
  106. NewAbstractMetaImpl(Text,Object, (TP(marks), TP(observers), T(tabWidth)));
  107.  
  108. Text::Text()
  109. { 
  110.     Init();
  111. }
  112.  
  113. Text::~Text()
  114. {   
  115.     if (marks) {
  116.     marks->FreeAll();
  117.     SafeDelete(marks);
  118.     }   
  119.     if (observers) 
  120.     CleanupObservers(observers);
  121. }
  122.  
  123. void Text::Init()
  124. {
  125.     marks= 0;
  126.     tabWidth= cTabw;
  127.     observers= 0;
  128.     paraStyle= new_ParaStyle();
  129.     charStyle= gCharStyles->Default();
  130. }
  131.  
  132. void Text::InitNew()
  133. {
  134.     Init();
  135. }
  136.  
  137. int Text::GrowSize(int minSize)
  138. {
  139.     if (cMaxInt - minSize > minSize)
  140.     return minSize+minSize;
  141.     int d= minSize-Size();
  142.     int m= Math::Min(2000, d);
  143.     if (cMaxInt - Size() > m)
  144.     return Size()+m;
  145.     Error("GrowSize", "Cannot grow text");
  146.     return 0;
  147. }
  148.  
  149. void Text::ReplaceRange(int, int, Text *, int, int)
  150. {
  151.     AbstractMethod("ReplaceRange");
  152. }
  153.  
  154. void Text::Cut(int from,int to)
  155. {
  156.     if (marks)
  157.     marks->Replace(from, to, 0);
  158.     Text *nullText= MakeScratchText(0, 0);
  159.     ReplaceRange(from, to, nullText, 0, 0);
  160.     SafeDelete(nullText);
  161.     Send(cIdNone, eTextDeleted, changeRec(from, to));     
  162. }
  163.  
  164. void Text::Paste(Text *src, int from, int to)
  165. {
  166.     if (marks) 
  167.     marks->Replace(from, to, src->End());
  168.     
  169.     ReplaceRange(from, to, src, 0, src->End());
  170.     Send(cIdNone, eTextReplaced, changeRec(from, to, src->End()));     
  171. }
  172.  
  173. void Text::Copy(Text *dst, int from, int to)
  174. {
  175.     dst->ReplaceRange(0, dst->End(), this, from, to);
  176. }
  177.  
  178. void Text::CopyInStr(byte*, int, int, int)
  179. {
  180.     AbstractMethod("CopyInStr");
  181. }
  182.  
  183. void Text::Insert(byte c, int from, int to)
  184. {
  185.     Text *t= MakeScratchText(&c, 1);
  186.     Paste(t, from, to);
  187.     SafeDelete(t);
  188. }
  189.  
  190. void Text::InsertStr(int from, int to, byte *str, int len)
  191. {
  192.     if (len == -1 && str)
  193.     len= strlen((char*)str);
  194.     Text *t= MakeScratchText(str, len);
  195.     Paste(t, from, to);
  196.     SafeDelete(t);
  197. }
  198.  
  199. void Text::ReplaceWithStr(byte *buf, int len)
  200. {
  201.     InsertStr(0, End(), buf, len);
  202. }
  203.  
  204. void Text::SetFStringVL(char *fmt, va_list va)
  205. {
  206.     byte *buf= (byte*)strvprintf(fmt, va);
  207.     ReplaceWithStr(buf, -1);
  208.     SafeDelete(buf);
  209. }
  210.  
  211. void Text::SetFString(char *va_(fmt), ...)
  212. {
  213.     va_list ap;
  214.     va_start(ap,va_(fmt));
  215.     SetFStringVL(va_(fmt), ap);
  216.     va_end(ap);    
  217. }
  218.  
  219. int Text::Search(
  220.     RegularExp *rex, int *nMatched, int start, int range, bool dir
  221. )
  222. {
  223.     int pos;
  224.     char *s= AsString();
  225.     if (dir == cSearchForward) 
  226.     pos= rex->SearchForward (s, nMatched, start, Size(), range, 0);
  227.     else
  228.     pos= rex->SearchBackward (s, nMatched, start, Size(), range, 0); 
  229.     delete s;
  230.     return pos;
  231. }
  232.  
  233. bool Text::IsParaStart(int at)
  234. {
  235.     return (at <= 0) || IsPara((*this)[at-1]);
  236. }
  237.  
  238. bool Text::IsParaEnd(int at)
  239. {
  240.     return (at >= Size()) || IsPara((*this)[at]);
  241. }
  242.  
  243. Text *Text::MakeScratchText(byte *, int) 
  244. {
  245.     AbstractMethod("MakeScratchText");
  246.     return 0;
  247. }
  248.  
  249. Text* Text::Save(int from, int to)
  250. {
  251.     if (!CheckRange(Size(), from, to))
  252.     Error("Save", "Out of range from= %d to=%d size= %d", from, to, Size());
  253.     Text *t= (Text*)this->New();
  254.     Copy(t, from, to);
  255.     return t;
  256. }
  257.  
  258. void Text::Append(byte c)
  259. {
  260.     int at= Math::Max(0, End());
  261.     Insert(c, at, at);
  262. }
  263.  
  264. byte& Text::operator[](int )
  265. {
  266.     static byte dummyc= '\0';
  267.     AbstractMethod("operator[]");
  268.     return dummyc;
  269. }
  270.  
  271. void Text::Empty()                                         
  272. {
  273.     Cut(0, End());
  274. }
  275.  
  276. int Text::Size()                                         
  277. {
  278.     AbstractMethod("Size");
  279.     return 0;
  280. }
  281.  
  282. void Text::GetWordRange(int at, int *start, int *end)
  283. {
  284.     register int i;
  285.  
  286.     if (!CheckRange(Size(), at, at))
  287.     return;
  288.  
  289.     for (i= at-1; i >= 0 && Isinword((*this)[i]); i--)
  290.     ;
  291.     *start= i+1; 
  292.     for (i= at; i < Size() && Isinword((*this)[i]); i++)
  293.     ; 
  294.     *end= i;
  295. }
  296.  
  297. void Text::GetParaRange(int at, int *start, int *end)
  298. {
  299.     register int i, ch;
  300.  
  301.     if (!CheckRange(Size(), at, at))
  302.     return;
  303.  
  304.     for (i= at-1; i >= 0; i--) {
  305.     ch= (*this)[i];
  306.     if (IsPara(ch))
  307.         break;
  308.     }
  309.     *start= i+1; 
  310.     for (i= at; i < Size(); i++) {
  311.     ch= (*this)[i];
  312.     if (IsPara(ch))
  313.         break; 
  314.     }
  315.     *end= Math::Min(Size(), i+1);
  316. }
  317.  
  318. int Text::FindLastBreak(int from)
  319. {
  320.     for (int i= from-1; i >= 0; i--)
  321.     if (IsBreak((*this)[i]))
  322.         break;
  323.     return i;
  324. }
  325.  
  326. int Text::FindNextBreak(int from)
  327. {
  328.     for (int i= from; i < Size(); i++)
  329.     if (IsBreak((*this)[i]))
  330.         break;
  331.     return i;
  332. }
  333.  
  334. void Text::SetDefTab(int t)
  335. {
  336.     tabWidth= t;
  337. }
  338.  
  339. int Text::GetDefTab()
  340. {
  341.     return tabWidth;
  342. }
  343.  
  344. TextIter *Text::MakeIterator(int,int)
  345. {
  346.     AbstractMethod("MakeIterator ");
  347.     return 0;    
  348. }
  349.  
  350. //---- style access
  351.  
  352. void Text::SetCharStyle(TxtCharProp what, int, int, const CharStyleSpec &st)
  353. {
  354.     charStyle= gCharStyles->ChangeProperty(charStyle, what, st);    
  355.     Send(cIdNone, eTextChangedRange, changeRec(0, Size()));     
  356. }
  357.  
  358. void Text::SetParaStyle(TxtParaProp what, int, int, const ParaDesc &pd)
  359. {
  360.     paraStyle= gParaStyles->ChangeProperty(paraStyle, what, pd);
  361.     Send(cIdNone, eTextChangedRange, changeRec(0, Size()));     
  362. }
  363.  
  364. CharStyle *Text::GetCharStyle(int)
  365. {
  366.     return charStyle;
  367. }
  368.  
  369. CharStyle *Text::GetCurrentCharStyle()
  370. {
  371.     return 0;
  372. }
  373.  
  374. ParaStyle *Text::GetParaStyle(int)
  375. {
  376.     return paraStyle;
  377. }
  378.  
  379. void Text::SetFont(Font *fd, int from, int to)
  380. {
  381.     SetCharStyle(eTxtCPFontAll, from, to, CharStyleSpec(fd));
  382. }
  383.  
  384. Font *Text::GetFont(int)
  385. {
  386.     return charStyle->GetFont();
  387. }
  388.  
  389. void Text::ResetCurrentCharStyle()
  390. {
  391. }
  392.  
  393. //---- TextPainter contract
  394.  
  395. int Text::GetNextFontChange(int, CharStyle *&sp)
  396. {
  397.     sp= charStyle;
  398.     return cMaxInt;
  399. }
  400.  
  401. byte Text::GetMarkChar()
  402. {
  403.     return 0;
  404. }
  405.  
  406. VisualMark *Text::GetVisualMarkAt(int)
  407. {
  408.     return 0;
  409. }
  410.  
  411. bool Text::IsVisualMark(int)
  412. {
  413.     return FALSE;
  414. }
  415.  
  416. byte *Text::GetLineAccess(byte**, int, int)
  417. {
  418.     AbstractMethod("GetLine");
  419.     return 0;
  420. }
  421.  
  422. //---- conversion
  423.  
  424. char *Text::AsString()
  425. {
  426.     int s= Size();
  427.     char *buf= new char[s];
  428.     CopyInStr((byte*)buf, s, 0, s);
  429.     return buf;    
  430. }
  431.  
  432. OStream& Text::PrintOn(OStream &s)
  433. {
  434.     Object::PrintOn(s);
  435.     return s << charStyle SP << paraStyle SP;
  436. }
  437.  
  438. IStream& Text::ReadFrom(IStream &s)
  439. {
  440.     Object::ReadFrom(s);
  441.     return s >> charStyle >> paraStyle;
  442. }
  443.  
  444. OStream& Text::PrintOnAsPureText(OStream &s)
  445. {
  446.     AbstractMethod("PrintOnAsPureText");
  447.     return s;
  448. }
  449.  
  450. IStream& Text::ReadFromAsPureText(IStream &s, long)
  451. {
  452.     AbstractMethod("ReadFromAsPureText");
  453.     return s;
  454. }
  455.  
  456. bool Text::IsEmpty() 
  457. {
  458.     return End() == 0;
  459. }
  460.  
  461. void Text::AddMark(Mark *m)
  462. {
  463.     if (marks == 0)
  464.     marks= new MarkList;
  465.     marks->Add(m);
  466. }
  467.  
  468. Mark *Text::RemoveMark(Mark *m)
  469. {
  470.     if (marks == 0)
  471.     marks= new MarkList;
  472.     return marks->Remove(m);
  473. }
  474.  
  475. Iterator *Text::GetMarkIter()
  476. {
  477.     if (marks == 0)
  478.     marks= new MarkList;
  479.     return marks->MakeIterator();
  480. }
  481.  
  482. MarkList *Text::GetMarkList()
  483. {
  484.     if (marks == 0)
  485.     marks= new MarkList;
  486.     return marks;
  487. }
  488.  
  489. void Text::InspectorId(char *b, int s)
  490. {
  491.     for (int i= 0; i < Math::Min(s-1, Size()-1); i++)
  492.     b[i]= (*this)[i];
  493.     b[i]= '\0';
  494. }
  495.  
  496. bool Text::IsEqual(Object *text)                                         
  497. {
  498.     if (text == 0 || ! text->IsKindOf(Text))
  499.     return FALSE;
  500.     byte *p1= (byte*)AsString();
  501.     byte *p2= (byte*)text->AsString();
  502.     int equal=  StrCmp(p1, p2, -1, sortmap) == 0;
  503.     SafeDelete(p1);
  504.     SafeDelete(p2);
  505.     return equal;
  506. }
  507.  
  508. u_long Text::Hash()                                         
  509. {
  510.     u_long hash;
  511.     byte *p= (byte*)AsString();
  512.     hash= strhash(p);
  513.     return hash;
  514. }
  515.  
  516. //---- observing ----------------------------------------------------------
  517.     
  518. Collection *Text::MakeObserverColl()
  519. {
  520.     return observers= new OrdCollection(4);
  521. }
  522.  
  523. Collection *Text::GetObservers()
  524. {    
  525.     return observers;
  526. }
  527.  
  528. void Text::DestroyObserverColl()
  529. {
  530.     SafeDelete(observers);
  531. }
  532.  
  533. void Text::SetObserverColl(Collection *cp)
  534. {
  535.     SafeDelete(observers);
  536.     observers= cp;
  537. }
  538.  
  539. //----- class TextIter ----------------------------------------------------
  540.  
  541. TextIter::TextIter(Text *s,int from,int to)
  542. { 
  543.     ct= s; 
  544.     ce= Math::Max(from,0); 
  545.     upto= Math::Min(to,s->Size());
  546. }
  547.  
  548. TextIter::~TextIter()
  549. { 
  550. }
  551.  
  552. void TextIter::Reset(Text *s,int from,int to)
  553. { 
  554.     ct= s; 
  555.     ce= Math::Max(from,0); 
  556.     upto= Math::Min(to,s->Size());
  557. }
  558.  
  559. int TextIter::operator()(int *, LineDesc*)  
  560. {
  561.     return cEOT;
  562. }
  563.  
  564. int TextIter::GetPos()  
  565. {
  566.     return ce;
  567. }
  568.  
  569. Font *TextIter::FontAt(int)
  570. { 
  571.     return ct->GetFont(); 
  572. } 
  573.  
  574. int TextIter::Unget()
  575. {
  576.     return ce= unget;
  577. }
  578.  
  579. int TextIter::Token(int*, LineDesc*)  
  580. {
  581.     return cEOT;
  582. }
  583.  
  584. int TextIter::GetLastPos()                 // get last position
  585. { 
  586.     return unget; 
  587. }
  588.  
  589. void TextIter::SetPos(int newPos)
  590. { 
  591.     ce= newPos; 
  592. }
  593.  
  594. AutoTextIter::AutoTextIter(Text *t, int from, int to)
  595. { 
  596.     ti= t->MakeIterator(from, to);
  597. }
  598.  
  599.